package com.ken.apollo.controller;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.ken.apollo.commons.result.R;
import com.ken.apollo.commons.result.ResultCode;
import com.ken.apollo.domain.entity.MailSenderConfig;
import com.ken.apollo.service.MailSenderConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * 邮件发送方配置API控制器
 *
 * @author Ken
 * @since 2025-08-25
 */
@Slf4j
@RestController
@RequestMapping("/api/mail/sender")
public class MailSenderConfigController {
    
    @Autowired
    private MailSenderConfigService mailSenderConfigService;
    
    /**
     * 获取启用的配置列表（用于下拉选择）
     */
    @GetMapping("/enabled")
    public R<List<MailSenderConfig>> getEnabledConfigs() {
        try {
            List<MailSenderConfig> list = mailSenderConfigService.listByCondition(null, null, true);
            // 不返回密码信息
            list.forEach(config -> config.setSenderPassword(null));
            return R.success(list);
        } catch (Exception e) {
            log.error("获取启用的邮件发送方配置列表失败", e);
            return R.fail("获取配置列表失败：" + e.getMessage());
        }
    }
    
    /**
     * 获取配置列表
     */
    @GetMapping("/list")
    public R<List<MailSenderConfig>> list(
            @RequestParam(required = false) String configName,
            @RequestParam(required = false) String senderEmail,
            @RequestParam(required = false) Boolean status) {
        
        try {
            List<MailSenderConfig> list = mailSenderConfigService.listByCondition(configName, senderEmail, status);
            return R.success(list);
        } catch (Exception e) {
            log.error("获取邮件发送方配置列表失败", e);
            return R.fail("获取配置列表失败：" + e.getMessage());
        }
    }
    
    /**
     * 获取配置详情
     */
    @GetMapping("/detail/{id}")
    public R<MailSenderConfig> detail(@PathVariable Long id) {
        try {
            MailSenderConfig config = mailSenderConfigService.getById(id);
            if (config == null) {
                return R.fail("配置不存在");
            }
            // 不返回密码信息
            config.setSenderPassword(null);
            return R.success(config);
        } catch (Exception e) {
            log.error("获取邮件发送方配置详情失败，ID：{}", id, e);
            return R.fail("获取配置详情失败：" + e.getMessage());
        }
    }
    
    /**
     * 创建配置
     */
    @PostMapping("/create")
    public R<String> create(@RequestBody MailSenderConfig config) {
        try {
            // 参数校验
            if (StrUtil.isBlank(config.getConfigName())) {
                return R.fail("配置名称不能为空");
            }
            if (StrUtil.isBlank(config.getSmtpHost())) {
                return R.fail("SMTP服务器地址不能为空");
            }
            if (ObjectUtil.isNull(config.getSmtpPort())) {
                return R.fail("SMTP端口不能为空");
            }
            if (StrUtil.isBlank(config.getSenderEmail())) {
                return R.fail("发送方邮箱不能为空");
            }
            if (StrUtil.isBlank(config.getSenderPassword())) {
                return R.fail("邮箱密码不能为空");
            }
            
            // 设置默认值
            if (config.getStatus() == null) {
                config.setStatus(true);
            }
            if (config.getSslEnable() == null) {
                config.setSslEnable(false);
            }
            if (config.getTlsEnable() == null) {
                config.setTlsEnable(true);
            }
            if (config.getAuthEnable() == null) {
                config.setAuthEnable(true);
            }
            if (config.getDebugEnable() == null) {
                config.setDebugEnable(false);
            }
            if (config.getIsDefault() == null) {
                config.setIsDefault(false);
            }
            if (config.getConnectionTimeout() == null) {
                config.setConnectionTimeout(10000);
            }
            if (config.getReadTimeout() == null) {
                config.setReadTimeout(10000);
            }
            
            // 如果设置为默认配置，需要先取消其他默认配置
            if (config.getIsDefault()) {
                mailSenderConfigService.setDefaultConfig(null);
            }
            
            boolean success = mailSenderConfigService.save(config);
            
            // 如果设置为默认配置，更新默认标识
            if (success && config.getIsDefault()) {
                mailSenderConfigService.setDefaultConfig(config.getId());
            }
            
            if (success) {
                return R.success("创建配置成功");
            } else {
                return R.fail("创建配置失败");
            }
        } catch (Exception e) {
            log.error("创建邮件发送方配置失败", e);
            return R.fail("创建配置失败：" + e.getMessage());
        }
    }
    
    /**
     * 更新配置
     */
    @PostMapping("/update")
    public R<String> update(@RequestBody MailSenderConfig config) {
        try {
            if (config.getId() == null) {
                return R.fail("配置ID不能为空");
            }
            
            MailSenderConfig existConfig = mailSenderConfigService.getById(config.getId());
            if (existConfig == null) {
                return R.fail("配置不存在");
            }
            
            // 如果密码为空，保持原密码
            if (StrUtil.isBlank(config.getSenderPassword())) {
                config.setSenderPassword(existConfig.getSenderPassword());
            }
            
            // 如果设置为默认配置，需要先取消其他默认配置
            if (config.getIsDefault() != null && config.getIsDefault() && !existConfig.getIsDefault()) {
                mailSenderConfigService.setDefaultConfig(config.getId());
            }
            
            boolean success = mailSenderConfigService.updateById(config);
            
            if (success) {
                return R.success("更新配置成功");
            } else {
                return R.fail("更新配置失败");
            }
        } catch (Exception e) {
            log.error("更新邮件发送方配置失败", e);
            return R.fail("更新配置失败：" + e.getMessage());
        }
    }
    
    /**
     * 删除配置
     */
    @PostMapping("/delete/{id}")
    public R<String> delete(@PathVariable Long id) {
        try {
            MailSenderConfig config = mailSenderConfigService.getById(id);
            if (config == null) {
                return R.fail("配置不存在");
            }
            
            if (config.getIsDefault()) {
                return R.fail("不能删除默认配置");
            }
            
            boolean success = mailSenderConfigService.removeById(id);
            
            if (success) {
                return R.success("删除配置成功");
            } else {
                return R.fail("删除配置失败");
            }
        } catch (Exception e) {
            log.error("删除邮件发送方配置失败，ID：{}", id, e);
            return R.fail("删除配置失败：" + e.getMessage());
        }
    }
    
    /**
     * 设置默认配置
     */
    @PostMapping("/setDefault/{id}")
    public R<String> setDefault(@PathVariable Long id) {
        try {
            boolean success = mailSenderConfigService.setDefaultConfig(id);
            
            if (success) {
                return R.success("设置默认配置成功");
            } else {
                return R.fail("设置默认配置失败");
            }
        } catch (Exception e) {
            log.error("设置默认邮件发送方配置失败，ID：{}", id, e);
            return R.fail("设置默认配置失败：" + e.getMessage());
        }
    }
    
    /**
     * 更新配置状态
     */
    @PostMapping("/updateStatus")
    public R<String> updateStatus(@RequestParam Long id, @RequestParam Boolean status) {
        try {
            boolean success = mailSenderConfigService.updateStatus(id, status);
            
            if (success) {
                return R.success("更新状态成功");
            } else {
                return R.fail("更新状态失败");
            }
        } catch (Exception e) {
            log.error("更新邮件发送方配置状态失败，ID：{}，状态：{}", id, status, e);
            return R.fail("更新状态失败：" + e.getMessage());
        }
    }
    
    /**
     * 测试配置
     */
    @PostMapping("/test")
    public R<String> test(@RequestParam Long configId, @RequestParam String testEmail) {
        try {
            if (StrUtil.isBlank(testEmail)) {
                return R.fail("测试邮箱不能为空");
            }
            
            boolean success = mailSenderConfigService.testConfig(configId, testEmail);
            
            if (success) {
                return R.success("测试邮件发送成功");
            } else {
                return R.fail("测试邮件发送失败");
            }
        } catch (Exception e) {
            log.error("测试邮件发送配置失败，配置ID：{}，测试邮箱：{}", configId, testEmail, e);
            return R.fail("测试失败：" + e.getMessage());
        }
    }
}